Shareware Grab Bag/Shareware Grab Bag.iso/011/miscutl1.arc/CBTA.AQM/$CBTA.ASM

Assembly Source File | 1984-04-08 | 5KB | 216 lines

    NAME    $CBTA
    PAGE    60,132
    TITLE    $CBTA - CONVERT BINARY TO ASCII
    COMMENT *

AUTHOR:     LEGARE COLEMAN

DATE:        1/1/84

VERSION:    1.00

REVISIONS:

FUNCTION:    THIS ROUTINE CONVERTS A 32 BIT SIGNED BINARY INTEGER TO
        TO A ASCII STRING.

INPUT:        AX = LOW 16 BITS OF BINARY INTEGER

        BX = HIGH 16 BITS OF BINARY INTEGER

        DS:DI = A(ASCII STRING BUFFER)

        CH = LEADING ZERO FILL BYTE.  IF CH = 00H, THEN THE
             ASCII STRING WILL BE LEFT JUSTIFIED IN THE BUFFER.
             IF CH NOT = 00H, THEN LEADING ZEROES IN THE ASCII
             STRING ARE REPLACED BY THE BYTE IN CH, AND THE ASCII
             STRING BUFFER MUST BE AT LEAST ELEVEN BYTES IN LENGTH.

OUTPUT:     IF CF = 0, NO ERROR

            STRING = CONVERTED INTEGER

            DS:DI = A(BYTE AFTER ASCII STRING IN BUFFER)

            CX = LENGTH OF UNUSED BUFFER

        IF CF NOT = 0, ERROR - BUFFER TOO SHORT

            STRING = HIGH DIGITS OF RESULT

*
    PAGE
DSEG    SEGMENT PARA PUBLIC 'DATA'
TABLE    DD    2000000000    ; CONVERSION TABLE
    DD    1000000000
    DD    900000000
    DD    800000000
    DD    700000000
    DD    600000000
    DD    500000000
    DD    400000000
    DD    300000000
    DD    200000000
    DD    100000000
    DD    90000000
    DD    80000000
    DD    70000000
    DD    60000000
    DD    50000000
    DD    40000000
    DD    30000000
    DD    20000000
    DD    10000000
    DD    9000000
    DD    8000000
    DD    7000000
    DD    6000000
    DD    5000000
    DD    4000000
    DD    3000000
    DD    2000000
    DD    1000000
    DD    900000
    DD    800000
    DD    700000
    DD    600000
    DD    500000
    DD    400000
    DD    300000
    DD    200000
    DD    100000
    DD    90000
    DD    80000
    DD    70000
    DD    60000
    DD    50000
    DD    40000
    DD    30000
    DD    20000
    DD    10000
    DD    9000
    DD    8000
    DD    7000
    DD    6000
    DD    5000
    DD    4000
    DD    3000
    DD    2000
    DD    1000
    DD    900
    DD    800
    DD    700
    DD    600
    DD    500
    DD    400
    DD    300
    DD    200
    DD    100
    DD    90
    DD    80
    DD    70
    DD    60
    DD    50
    DD    40
    DD    30
    DD    20
    DD    10
    DD    9
    DD    8
    DD    7
    DD    6
    DD    5
    DD    4
    DD    3
    DD    2
    DD    1
DSEG    ENDS
    PAGE
CSEG    SEGMENT PARA PUBLIC 'CODE'
    PUBLIC    $CBTA
    EXTRN    SAVREG:NEAR
    ASSUME    CS:CSEG,DS:DSEG,SS:NOTHING,ES:NOTHING
$CBTA    PROC    NEAR
    CALL    SAVREG        ; SAVE REGISTERS
    SUB    DX,DX        ; DX = 0
    MOV    DL,CH        ; DL = LEADING ZERO FILL BYTE
    PUSH    DX        ; PUT FILL BYTE IN STACK WORK AREA
    SUB    CH,CH        ; CH = 0
    PUSH    CX        ; PUT BUFFER LENGTH IN STACK WORK AREA
    MOV    CX,10        ; CX = 10
    PUSH    CX        ; PUT DIGIT COUNT IN STACK WORK AREA
    MOV    BP,SP        ; BP = A(STACK WORK AREA)
    AND    BX,BX        ; INTEGER NEGATIVE ?
    JNS    $100        ; IF NS, NO
    NEG    AX        ; MAKE IT POSITIVE
    NOT    BX
    DEC    WORD PTR [BP+2] ; DECREMENT STRING LENGTH
    JS    $900        ; IF S, BUFFER TOO SMALL
    MOV    BYTE PTR [DI],'-'       ; PUT MINUS SIGN IN BUFFER
    INC    DI        ; DI = A(NEXT BUFFER BYTE)
$100:
    MOV    CX,2        ; CX = FIRST LOOP COUNT
    MOV    SI,OFFSET TABLE ; SI = A(CONVERSION TABLE)
$200:
    CMP    BX,[SI+2]    ; VALUE < TABLE ENTRY ?
    JB    $300        ; IF B, YES
    JA    $400        ; IF A, VALUE > TABLE ENTRY
    CMP    AX,[SI]     ; VALUE < TABLE ENTRY ?
    JB    $300        ; IF B, YES
    JMP    $400        ; VALUE >= TABLE ENTRY
$300:
    ADD    SI,4        ; SI = A(NEXT TABLE ENTRY)
    LOOP    $200        ; LOOP IF NOT DONE
    JMP    $500        ; NEXT DIGIT = ZERO
$400:
    SUB    AX,[SI]     ; VALUE - TABLE ENTRY
    SBB    BX,[SI+2]
$500:
    MOV    CH,CL        ; CH = INDEX
    MOV    DX,[BP+4]    ; DH = FLAG, DL = FILL BYTE
    AND    DH,DH        ; SIGNIFICANT DIGIT YET ?
    JNZ    $800        ; IF NZ, YES
    AND    CL,CL        ; IS THIS A LEADING ZERO ?
    JNZ    $700        ; IF NZ, NO
    AND    DL,DL        ; IS THERE A FILL BYTE ?
    JZ    $600        ; IF Z, NO
    DEC    WORD PTR [BP+2] ; DECREMENT LENGTH REMAINING IN BUFFER
    JS    $900        ; IF S, ERROR - BUFFER TOO SMALL
    MOV    [DI],DL     ; PUT FILL BYTE IN BUFFER
    INC    DI        ; DI = A(NEXT BUFFER BYTE)
$600:
    MOV    CX,9        ; CX = NEXT LOOP COUNT
    DEC    WORD PTR [BP]    ; DECREMENT DIGIT COUNT
    JNZ    $200        ; IF NZ, CONTINUE CONVERSION
    JMP    $1000        ; EXIT - CONVERSION COMPLETE
$700:
    INC    DH        ; SET SIGNIFICANT DIGIT FLAG
    MOV    [BP+4],DX    ; STORE FLAG
$800:
    DEC    WORD PTR [BP+2] ; DECREMENT LENGTH REMAINING IN BUFFER
    JS    $900        ; IF S, ERROR - BUFFER TOO SMALL
    OR    CH,30H        ; CH = ASCII DIGIT
    MOV    [DI],CH     ; PUT DIGIT IN BUFFER
    INC    DI        ; DI = A(NEXT BYTE IN BUFFER)
    SUB    CH,CH        ; CH = 0
    SHL    CX,1        ; CX = INDEX * 2
    SHL    CX,1        ; CX = INDEX * 4
    ADD    SI,CX        ; SI = A(NEXT TABLE ENTRY)
    JMP    $600        ; GO TO NEXT DIGIT
$900:
    ADD    SP,6        ; REMOVE WORK AREA FROM STACK
    STC            ; SET ERROR FLAG
    RET            ; RETURN TO CALLER
$1000:
    POP    CX        ; REMOVE WORK AREA FROM STACK
    POP    CX        ; CX = LENGTH REMAINING IN BUFFER
    POP    AX        ; REMOVE WORK AREA FROM STACK
    MOV    BP,SP        ; BP = A(TOP OF STACK)
    MOV    [BP+14],CX    ; PUT UNUSED BUFFER LENGTH IN RETURN REGISTER
    MOV    [BP+6],DI    ; PUT A(NEXT BUFFER BYTE) IN RETURN REGISTER
    CLC            ; CLEAR ERROR FLAG
    RET            ; RETURN TO CALLER
$CBTA    ENDP
CSEG    ENDS
    END